home *** CD-ROM | disk | FTP | other *** search
/ Aminet 35 / Aminet 35 (2000)(Schatztruhe)[!][Feb 2000].iso / Aminet / game / shoot / ADescentSrc.lha / descent / 2d / scale.c < prev   
C/C++ Source or Header  |  1998-09-26  |  13KB  |  472 lines
  1. /*
  2. THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
  3. SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
  4. END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
  5. ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
  6. IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
  7. SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
  8. FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
  9. CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
  10. AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.  
  11. COPYRIGHT 1993-1998 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
  12. */
  13. #include "gr.h"
  14. #include "grdef.h"
  15.  
  16. #ifdef VIRGIN
  17. #include <cybergraphics/cybergraphics.h>
  18. #include <inline/cybergraphics.h>
  19. #include <inline/intuition.h>
  20. #include <intuition/intuition.h>
  21. #include <inline/graphics.h>
  22. #include <graphics/gfx.h>
  23. #include <inline/exec.h>
  24. #include <exec/exec.h>
  25. #include <cybergraphics/cgx3dvirgin.h>
  26. #include <clib/cgx3dvirgin_protos.h>
  27. #include <inline/cgx3dvirgin.h>
  28.  
  29. #include "VirgeTexture.h"
  30. extern UWORD BitValues[256];
  31. #endif
  32.  
  33. #ifdef WARP3D
  34. #include "Warp3D.h"
  35. #endif
  36.  
  37. // John's new stuff below here....
  38.  
  39. int scale_error_term;
  40. int scale_initial_pixel_count;
  41. int scale_adj_up;
  42. int scale_adj_down;
  43. int scale_final_pixel_count;
  44. int scale_ydelta_minus_1;
  45. int scale_whole_step;
  46. ubyte * scale_source_ptr;
  47. #if !defined(VIRGIN) && !defined(WARP3D)
  48. ubyte * scale_dest_ptr;
  49. #else
  50. UWORD * scale_dest_ptr;
  51. #endif
  52.  
  53. #if defined(VIRGIN) || defined(WARP3D)
  54. #define c2px(c) BitValues[c]
  55. #define PSIZE 2
  56. #else
  57. #define c2px(c) (c)
  58. #define PSIZE 1
  59. #endif
  60.  
  61.  
  62. ubyte scale_rle_data[640];
  63.  
  64. void scale_up_bitmap(grs_bitmap *source_bmp, grs_bitmap *dest_bmp, int x0, int y0, int x1, int y1, fix u0, fix v0,  fix u1, fix v1  );
  65. void scale_up_bitmap_rle(grs_bitmap *source_bmp, grs_bitmap *dest_bmp, int x0, int y0, int x1, int y1, fix u0, fix v0,  fix u1, fix v1  );
  66. void rls_stretch_scanline_setup( int XDelta, int YDelta );
  67. void rls_stretch_scanline(void);
  68.  
  69.  
  70. void decode_row( grs_bitmap * bmp, int y )
  71. {
  72.     int i, offset=4+bmp->bm_h;
  73.     
  74.     for (i=0; i<y; i++ )
  75.         offset += bmp->bm_data[4+i];
  76.     gr_rle_decode( &bmp->bm_data[offset], scale_rle_data );
  77. }
  78.  
  79. void scale_up_bitmap(grs_bitmap *source_bmp, grs_bitmap *dest_bmp, int x0, int y0, int x1, int y1, fix u0, fix v0,  fix u1, fix v1  )
  80. {
  81.     fix dv, v;
  82.     int y;
  83. #if defined(VIRGIN)
  84.     UWORD *RenderBuffer = (UWORD *)VirgeGetBuffer();
  85.     extern int VirgeBytesPerRow;
  86. #elif defined(WARP3D)
  87.     UWORD *RenderBuffer = (UWORD *)WARP_GetBufferAddress();
  88. #endif
  89.  
  90.     dv = (v1-v0) / (y1-y0);
  91.         
  92.     rls_stretch_scanline_setup( (int)(x1-x0), f2i(u1)-f2i(u0) );
  93.     if ( scale_ydelta_minus_1 < 1 ) return;
  94.  
  95.     v = v0;
  96.  
  97.     for (y=y0; y<=y1; y++ )         {
  98.         scale_source_ptr = &source_bmp->bm_data[source_bmp->bm_rowsize*f2i(v)+f2i(u0)];
  99.     #if !defined(VIRGIN) && !defined(WARP3D)
  100.         scale_dest_ptr = &dest_bmp->bm_data[dest_bmp->bm_rowsize*y+x0];
  101.     #else
  102.         scale_dest_ptr = RenderBuffer + (VirgeBytesPerRow/2)*y+x0;
  103.     #endif
  104.         rls_stretch_scanline();
  105.         v += dv;
  106.     }
  107. }
  108.  
  109.  
  110.  
  111.  
  112. void scale_up_bitmap_rle(grs_bitmap *source_bmp, grs_bitmap *dest_bmp, int x0, int y0, int x1, int y1, fix u0, fix v0,  fix u1, fix v1  )
  113. {
  114.     fix dv, v;
  115.     int y, last_row = -1;
  116. #if defined(VIRGIN)
  117.     UWORD *RenderBuffer = (UWORD *)VirgeGetBuffer();
  118.     extern int VirgeBytesPerRow;
  119. #elif defined(WARP3D)
  120.     UWORD *RenderBuffer = (UWORD *)WARP_GetBufferAddress();
  121. #endif
  122.  
  123.     dv = (v1-v0) / (y1-y0);
  124.         
  125.     rls_stretch_scanline_setup( (int)(x1-x0), f2i(u1)-f2i(u0) );
  126.     if ( scale_ydelta_minus_1 < 1 ) return;
  127.  
  128.     v = v0;
  129.  
  130.     for (y=y0; y<=y1; y++ )         {
  131.         if ( f2i(v) != last_row )   {
  132.             last_row = f2i(v);
  133.             decode_row( source_bmp, last_row );
  134.         }
  135.         scale_source_ptr = &scale_rle_data[f2i(u0)];
  136.     #if !defined(VIRGIN) && !defined(WARP3D)
  137.         scale_dest_ptr = &dest_bmp->bm_data[dest_bmp->bm_rowsize*y+x0];
  138.     #else
  139.         scale_dest_ptr = RenderBuffer + (VirgeBytesPerRow/2)*y+x0;
  140.     #endif
  141.         rls_stretch_scanline();
  142.         v += dv;
  143.     }
  144. }
  145.  
  146. void rls_stretch_scanline_setup( int XDelta, int YDelta )
  147. {
  148.       scale_ydelta_minus_1 = YDelta - 1;
  149.  
  150.       /* X major line */
  151.       /* Minimum # of pixels in a run in this line */
  152.       scale_whole_step = XDelta / YDelta;
  153.  
  154.       /* Error term adjust each time Y steps by 1; used to tell when one
  155.          extra pixel should be drawn as part of a run, to account for
  156.          fractional steps along the X axis per 1-pixel steps along Y */
  157.       scale_adj_up = (XDelta % YDelta) * 2;
  158.  
  159.       /* Error term adjust when the error term turns over, used to factor
  160.          out the X step made at that time */
  161.       scale_adj_down = YDelta * 2;
  162.  
  163.       /* Initial error term; reflects an initial step of 0.5 along the Y
  164.          axis */
  165.       scale_error_term = (XDelta % YDelta) - (YDelta * 2);
  166.  
  167.       /* The initial and last runs are partial, because Y advances only 0.5
  168.          for these runs, rather than 1. Divide one full run, plus the
  169.          initial pixel, between the initial and last runs */
  170.       scale_initial_pixel_count = (scale_whole_step / 2) + 1;
  171.       scale_final_pixel_count = scale_initial_pixel_count;
  172.  
  173.       /* If the basic run length is even and there's no fractional
  174.          advance, we have one pixel that could go to either the initial
  175.          or last partial run, which we'll arbitrarily allocate to the
  176.          last run */
  177.       if ((scale_adj_up == 0) && ((scale_whole_step & 0x01) == 0))
  178.       {
  179.          scale_initial_pixel_count--;
  180.       }
  181.      /* If there're an odd number of pixels per run, we have 1 pixel that can't
  182.      be allocated to either the initial or last partial run, so we'll add 0.5
  183.      to error term so this pixel will be handled by the normal full-run loop */
  184.       if ((scale_whole_step & 0x01) != 0)
  185.       {
  186.          scale_error_term += YDelta;
  187.       }
  188.  
  189. }
  190.  
  191. void rls_stretch_scanline()
  192. {
  193.     ubyte   c;
  194.     int i, j, len, ErrorTerm, x;
  195.  
  196.     // Setup initial variables
  197.     ErrorTerm = scale_error_term;
  198.  
  199.     // Draw the first, partial run of pixels
  200.  
  201.     c = *scale_source_ptr++;
  202.     if ( c != TRANSPARENCY_COLOR )  {
  203.         for (i=0; i<scale_initial_pixel_count; i++ )
  204.             *scale_dest_ptr++ = c2px(c);
  205.     } else {
  206.         scale_dest_ptr += scale_initial_pixel_count;
  207.     }
  208.  
  209.     // Draw all full runs 
  210.  
  211.     for (j=0; j<scale_ydelta_minus_1; j++)  {
  212.         len = scale_whole_step;     // run is at least this long
  213.  
  214.         // Advance the error term and add an extra pixel if the error term so indicates
  215.         if ((ErrorTerm += scale_adj_up) > 0)    {
  216.             len++;
  217.             ErrorTerm -= scale_adj_down;   // reset the error term
  218.         }
  219.          
  220.         // Draw this run o' pixels
  221.         c = *scale_source_ptr++;
  222.         if ( c != TRANSPARENCY_COLOR )  {
  223.         #if !defined(VIRGIN) && !defined(WARP3D)
  224.             if (len > 3) {          
  225.                 while ((int)(scale_dest_ptr) & 0x3) { *scale_dest_ptr++ = c; len--; };
  226.                 if (len >= 4) {
  227.                     x = (c << 24) | (c << 16) | (c << 8) | c;
  228.                     while (len > 4) { *((int *)scale_dest_ptr) = x; scale_dest_ptr += 4; len -= 4; };
  229.                 }
  230.                 while (len > 0) { *scale_dest_ptr++ = c; len--; };
  231.             } else {
  232.                 for (i=0; i<len; i++ )
  233.                     *scale_dest_ptr++ = c;
  234.             }
  235.         #else
  236.             for (i=0; i<len; i++) *scale_dest_ptr++ = c2px(c);
  237.         #endif
  238.         } else {
  239.             scale_dest_ptr += len;
  240.         }
  241.     }
  242.  
  243.     // Draw the final run of pixels
  244.     c = *scale_source_ptr++;
  245.     if ( c != TRANSPARENCY_COLOR )  {
  246.         for (i=0; i<scale_final_pixel_count; i++ )
  247.             *scale_dest_ptr++ = c2px(c);
  248.     } else {
  249.         scale_dest_ptr += scale_final_pixel_count;
  250.     }
  251. }
  252.  
  253. // old stuff here...
  254.  
  255. void scale_bitmap_c(grs_bitmap *source_bmp, grs_bitmap *dest_bmp, int x0, int y0, int x1, int y1, fix u0, fix v0,  fix u1, fix v1  )
  256. {
  257.     fix u, v, du, dv;
  258.     int x, y;
  259.     ubyte * sbits, * dbits;
  260.  
  261.     du = (u1-u0) / (x1-x0);
  262.     dv = (v1-v0) / (y1-y0);
  263.  
  264.     v = v0;
  265.  
  266.     for (y=y0; y<=y1; y++ )         {
  267.         sbits = &source_bmp->bm_data[source_bmp->bm_rowsize*f2i(v)];
  268.         dbits = &dest_bmp->bm_data[dest_bmp->bm_rowsize*y+x0];
  269.         u = u0; 
  270.         v += dv;
  271.         for (x=x0; x<=x1; x++ )         {
  272.             *dbits++ = sbits[ u >> 16 ];
  273.             u += du;
  274.         }
  275.     }
  276. }
  277.  
  278. void scale_row_asm_transparent( ubyte * sbits, ubyte * dbits, int width, fix u, fix du )
  279. {
  280.     int i;
  281.     ubyte c;
  282.     #if defined(VIRGIN) || defined(WARP3D)
  283.     ubyte *dbits_end = &dbits[2*(width-1)];
  284.     #else
  285.     ubyte *dbits_end = &dbits[width-1];
  286.     #endif
  287.  
  288.     if ( du < F1_0 )    {
  289.         // Scaling up.
  290.         fix next_u;
  291.         int next_u_int;
  292.  
  293.         next_u_int = f2i(u)+1;
  294.         c = sbits[ next_u_int ];
  295.         next_u = i2f(next_u_int);
  296.         if ( c != TRANSPARENCY_COLOR ) goto NonTransparent;
  297.  
  298. Transparent:
  299.         while (1)   {
  300.         #if defined(VIRGIN) || defined(WARP3D)
  301.             dbits+=2;
  302.         #else
  303.             dbits++;
  304.         #endif
  305.             if ( dbits > dbits_end ) return;
  306.             u += du;
  307.             if ( u > next_u )   {
  308.                 next_u_int = f2i(u)+1;
  309.                 c = sbits[ next_u_int ];
  310.                 next_u = i2f(next_u_int);
  311.                 if ( c != TRANSPARENCY_COLOR ) goto NonTransparent;
  312.             }
  313.         }
  314.         return;
  315.  
  316. NonTransparent:
  317.         while (1)   {
  318.             #if defined(VIRGIN) || defined(WARP3D)
  319.             *(UWORD *)dbits=c2px(c);
  320.             #else
  321.             *dbits++ = c;
  322.             #endif
  323.             if ( dbits > dbits_end ) return;
  324.             u += du;
  325.             if ( u > next_u )   {
  326.                 next_u_int = f2i(u)+1;
  327.                 c = sbits[ next_u_int ];
  328.                 next_u = i2f(next_u_int);
  329.                 if ( c == TRANSPARENCY_COLOR ) goto Transparent;
  330.             }
  331.         }
  332.         return;
  333.  
  334.  
  335.  
  336.     } else {
  337.         for ( i=0; i<width; i++ )   {
  338.             c = sbits[ f2i(u) ];
  339.     
  340.             if ( c != TRANSPARENCY_COLOR )
  341.             #if defined(VIRGIN) || defined(WARP3D)
  342.                 *(UWORD *)dbits = c2px(c);
  343.             #else
  344.                 *dbits = c;
  345.             #endif
  346.                 
  347.             #if defined(VIRGIN) || defined(WARP3D)
  348.             dbits+=2;
  349.             #else
  350.             dbits++;
  351.             #endif
  352.             u += du;
  353.         }
  354.     }
  355. }
  356.  
  357. void scale_bitmap_c_rle(grs_bitmap *source_bmp, grs_bitmap *dest_bmp, int x0, int y0, int x1, int y1, fix u0, fix v0,  fix u1, fix v1  )
  358. {
  359.     fix du, dv, v;
  360.     int y, last_row=-1;
  361.  
  362. #if defined(VIRGIN)
  363.     UWORD *RenderBuffer = (UWORD *)VirgeGetBuffer();
  364.     extern int VirgeBytesPerRow;
  365. #endif
  366. #ifdef WARP3D
  367.     UWORD *RenderBuffer = (UWORD *)VirgeGetBuffer();
  368. #endif
  369.  
  370.     du = (u1-u0) / (x1-x0);
  371.     dv = (v1-v0) / (y1-y0);
  372.  
  373.     v = v0;
  374.  
  375.     for (y=y0; y<=y1; y++ )         {
  376.         if ( f2i(v) != last_row )   {
  377.             last_row = f2i(v);
  378.             decode_row( source_bmp, last_row );
  379.         }
  380.         scale_row_asm_transparent( scale_rle_data,
  381.         #if defined(VIRGIN) || defined(WARP3D)
  382.             (ubyte *)(RenderBuffer + (VirgeBytesPerRow/2)*y+x0),
  383.         #else
  384.             &dest_bmp->bm_data[dest_bmp->bm_rowsize*y+x0],
  385.         #endif
  386.             x1-x0+1, u0, du );
  387.         v += dv;
  388.     }
  389. }
  390.  
  391. #define FIND_SCALED_NUM(x,x0,x1,y0,y1) (fixmuldiv((x)-(x0),(y1)-(y0),(x1)-(x0))+(y0))
  392.  
  393. // Scales bitmap, bp, into vertbuf[0] to vertbuf[1]
  394. void scale_bitmap(grs_bitmap *bp, grs_point *vertbuf )
  395. {
  396.     grs_bitmap * dbp = &grd_curcanv->cv_bitmap;
  397.     fix x0, y0, x1, y1;
  398.     fix u0, v0, u1, v1;
  399.     fix clipped_x0, clipped_y0, clipped_x1, clipped_y1;
  400.     fix clipped_u0, clipped_v0, clipped_u1, clipped_v1;
  401.     fix xmin, xmax, ymin, ymax;
  402.     int dx0, dy0, dx1, dy1;
  403.     int dtemp;
  404.     // Set initial variables....
  405.  
  406.     x0 = vertbuf[0].x; y0 = vertbuf[0].y;
  407.     x1 = vertbuf[2].x; y1 = vertbuf[2].y;
  408.  
  409.     xmin = 0; ymin = 0;
  410.     xmax = i2f(dbp->bm_w)-fl2f(.5); ymax = i2f(dbp->bm_h)-fl2f(.5);
  411.  
  412.     u0 = i2f(0); v0 = i2f(0);
  413.     u1 = i2f(bp->bm_w-1); v1 = i2f(bp->bm_h-1);
  414.  
  415.     // Check for obviously offscreen bitmaps...
  416.     if ( (y1<=y0) || (x1<=x0) ) return;
  417.     if ( (x1<0 ) || (x0>=xmax) ) return;
  418.     if ( (y1<0 ) || (y0>=ymax) ) return;
  419.  
  420.     clipped_u0 = u0; clipped_v0 = v0;
  421.     clipped_u1 = u1; clipped_v1 = v1;
  422.  
  423.     clipped_x0 = x0; clipped_y0 = y0;
  424.     clipped_x1 = x1; clipped_y1 = y1;
  425.  
  426.     // Clip the left, moving u0 right as necessary
  427.     if ( x0 < xmin )    {
  428.         clipped_u0 = FIND_SCALED_NUM(xmin,x0,x1,u0,u1);
  429.         clipped_x0 = xmin;
  430.     }
  431.  
  432.     // Clip the right, moving u1 left as necessary
  433.     if ( x1 > xmax )    {
  434.         clipped_u1 = FIND_SCALED_NUM(xmax,x0,x1,u0,u1);
  435.         clipped_x1 = xmax;
  436.     }
  437.  
  438.     // Clip the top, moving v0 down as necessary
  439.     if ( y0 < ymin )    {
  440.         clipped_v0 = FIND_SCALED_NUM(ymin,y0,y1,v0,v1);
  441.         clipped_y0 = ymin;
  442.     }
  443.  
  444.     // Clip the bottom, moving v1 up as necessary
  445.     if ( y1 > ymax )    {
  446.         clipped_v1 = FIND_SCALED_NUM(ymax,y0,y1,v0,v1);
  447.         clipped_y1 = ymax;
  448.     }
  449.     
  450.     dx0 = f2i(clipped_x0); dx1 = f2i(clipped_x1);
  451.     dy0 = f2i(clipped_y0); dy1 = f2i(clipped_y1);
  452.  
  453.     if (dx1<=dx0) return;
  454.     if (dy1<=dy0) return;
  455.  
  456.  
  457.     dtemp = f2i(clipped_u1)-f2i(clipped_u0);
  458.  
  459.     if ( bp->bm_flags & BM_FLAG_RLE )   {
  460.         if ( (dtemp < (f2i(clipped_x1)-f2i(clipped_x0))) && (dtemp>0) )
  461.             scale_up_bitmap_rle(bp, dbp, dx0, dy0, dx1, dy1, clipped_u0, clipped_v0, clipped_u1, clipped_v1  );
  462.         else
  463.             scale_bitmap_c_rle(bp, dbp, dx0, dy0, dx1, dy1, clipped_u0, clipped_v0, clipped_u1, clipped_v1  );
  464.     } else {
  465.         if ( (dtemp < (f2i(clipped_x1)-f2i(clipped_x0))) && (dtemp>0) )
  466.             scale_up_bitmap(bp, dbp, dx0, dy0, dx1, dy1, clipped_u0, clipped_v0, clipped_u1, clipped_v1  );
  467.         else
  468.             scale_bitmap_c(bp, dbp, dx0, dy0, dx1, dy1, clipped_u0, clipped_v0, clipped_u1, clipped_v1  );
  469.     }
  470. }
  471.  
  472.